home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Amiga Plus 1995 #5 & #6
/
Amiga Plus CD - 1995 - No. 5 and 6.iso
/
pd
/
daten
/
ispell
/
interfaces
/
willy-ttx
/
quicksort-source
/
quicksort.c
< prev
Wrap
C/C++ Source or Header
|
1992-09-28
|
9KB
|
336 lines
/* A test program to demonstrate the direct variable interface to ARexx.
* Opens a public port called "VarTest" and then waits for REXX messages.
* The port stays open until a "CLOSE" command is received.
* Usage: run vartest
* Then send commands from within ARexx by "address 'VarTest' command"
*
* This version for Manx. WGL
* This version for SAS
*/
/*
* Standard includes for SAS C.
*/
#include <exec/types.h>
#include <exec/exec.h>
#include <intuition/intuitionbase.h>
#include <intuition/gadgetclass.h>
#include <libraries/gadtools.h>
#include <graphics/gfxbase.h>
#include <graphics/text.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <proto/rexxsys.h>
#include <proto/all.h>
/*
* Prototypes for functions defined in RexxVars.o
*/
long __stdargs SetRexxVar(struct RexxMsg *, unsigned char *, unsigned char *,
long);
long __stdargs GetRexxVar(struct RexxMsg *, unsigned char *, STRPTR *, long);
long __stdargs CheckRexxMsg(struct RexxMsg *);
static long Sort(struct List *);
static void ReturnMsg(struct RexxMsg *, long, long);
static struct List *AddList(struct List *, char *, long);
static struct List *NukeList(struct List *);
static struct List *GetRexxList(struct RexxMsg *, long);
static struct List *PutRexxList(struct RexxMsg *, struct List *);
struct Node *ListRequest(struct Screen *, struct List *, long, long, long, long);
struct RexxLib *RexxSysBase = NULL;
struct IntuitionBase *IntuitionBase = NULL;
struct GfxBase *GfxBase = NULL;
struct Library *GadToolsBase = NULL;
#define DO_SORT 1
#define NO_SORT 0
void main(int argc, char **argv)
{
struct MsgPort *MyPort = NULL;
struct RexxMsg *rmptr;
long quitflag = 0, sortflag;
long res1, res2, x = 0, y = 0, w = 0, h = 0, n;
struct List *list = NULL;
struct Node *result;
char *screenname = NULL, *flags = NULL, *ptr;
struct Screen *screen = NULL;
RexxSysBase = (struct RexxLib *) OpenLibrary("rexxsyslib.library",0);
if (RexxSysBase == 0L) goto cleanup;
IntuitionBase = (struct RexxLib *) OpenLibrary("intuition.library",0);
if (IntuitionBase == 0L) goto cleanup;
GfxBase = (struct RexxLib *) OpenLibrary("graphics.library",0);
if (GfxBase == 0L) goto cleanup;
GadToolsBase = (struct RexxLib *) OpenLibrary("gadtools.library",0);
if (GadToolsBase == 0L) goto cleanup;
MyPort = CreatePort("QuickSortPort", NULL);
if (MyPort == NULL) goto cleanup;
while (quitflag == 0) {
Wait(1L << MyPort->mp_SigBit);
rmptr = (struct RexxMsg *) GetMsg(MyPort);
res1 = res2 = 0L;
if (CheckRexxMsg(rmptr)) {
if (stricmp(rmptr->rm_Args[0], "QSORT") == 0) {
if ((rmptr->rm_Action & 0xFF) == 3) {
/*
* Get the strings array using insertion sort
*/
list = GetRexxList(rmptr, DO_SORT);
/*
* Now put them back.
*/
if (list) list = PutRexxList(rmptr, list);
if (list == NULL) {
res1 = 10L;
res2 = 12L;
}
list = NukeList(list);
}
else {
res1 = 10;
res2 = 17;
}
}
else if (stricmp(rmptr->rm_Args[0], "LISTREQUEST") == 0) {
if ((n = (rmptr->rm_Action & 0xFF)) < 4) {
res1 = 10;
res2 = 17;
}
else {
if (n >= 5) x = atol(rmptr->rm_Args[5]);
if (n >= 6) y = atol(rmptr->rm_Args[6]);
if (n >= 7) w = atol(rmptr->rm_Args[7]);
if (n >= 8) h = atol(rmptr->rm_Args[8]);
if (n >= 9) screenname = rmptr->rm_Args[9];
if (n >= 10) flags = rmptr->rm_Args[10];
sortflag = NO_SORT;
if (flags && (stricmp(flags, "SORT") == 0)) sortflag = DO_SORT;
list = GetRexxList(rmptr, sortflag);
if (list) {
if (screenname) screen = LockPubScreen(screenname);
result = ListRequest(screen, list, x, y, w, h);
if (screen) UnlockPubScreen(NULL, screen);
if (result) ptr = result->ln_Name;
else ptr = "";
SetRexxVar(rmptr, rmptr->rm_Args[4], ptr, strlen(ptr));
list = NukeList(list);
}
else {
res1 = 10L;
res2 = 12L;
}
}
}
/*
* See whether it's the close command
*/
else if (strcmp(rmptr->rm_Args[0], "CLOSE") == 0) {
quitflag = 1;
}
else if (strcmp(rmptr->rm_Args[0], "QUIT") == 0) {
quitflag = 1;
}
else {
res1 = 5;
res2 = 1;
}
}
else {
res1 = 10;
res2 = 10;
}
/*
* If we get here, we handled the command, but didn't return yet.
*/
ReturnMsg(rmptr, res1, res2);
}
cleanup:
if (MyPort) DeletePort(MyPort);
if (RexxSysBase) CloseLibrary(RexxSysBase);
if (GadToolsBase) CloseLibrary(GadToolsBase);
if (GfxBase) CloseLibrary(GfxBase);
if (IntuitionBase) CloseLibrary(IntuitionBase);
exit(0);
}
static struct List *GetRexxList(rmptr, sortflag)
struct RexxMsg *rmptr;
long sortflag;
{
long left, right, i, error;
char buffer[256];
STRPTR value;
struct List *list = NULL;
/*
* Get left and right bounds of string array to be sorted
*/
left = atoi(rmptr->rm_Args[1]);
right = atoi(rmptr->rm_Args[2]);
/*
* Copy RexxVariable array into strings
*/
for (i = left; i <= right; i++) {
/*
* Put name of stem in buffer
*/
sprintf(buffer, "%s.%d", rmptr->rm_Args[3], i);
/*
* Now get the string from the program
*/
error = GetRexxVar(rmptr, buffer, &value, 256);
if (error) {
list = NukeList(list);
break;
}
list = AddList(list, (char *) value, sortflag);
}
return(list);
}
static struct List *PutRexxList(rmptr, list)
struct RexxMsg *rmptr;
struct List *list;
{
long left, right, i, error;
char buffer[256], *ptr;
struct Node *n;
/*
* Get left and right bounds of string array to be sorted
*/
left = atoi(rmptr->rm_Args[1]);
right = atoi(rmptr->rm_Args[2]);
/*
* Put sort ed array back in old stem variable
*/
for (i = left, n = list->lh_Head; i <= right; i++, n = n->ln_Succ) {
/*
* Put name of stem in buffer
*/
sprintf(buffer, "%s.%d", rmptr->rm_Args[3], i);
ptr = n->ln_Name;
/*
* Now get the string from the program
*/
error = SetRexxVar(rmptr, buffer, ptr, strlen(ptr));
if (error) {
list = NukeList(list);
break;
}
}
return(list);
}
static void ReturnMsg(rmptr, res1, res2)
struct RexxMsg *rmptr;
long res1, res2;
{
rmptr->rm_Result1 = res1;
rmptr->rm_Result2 = res2;
ReplyMsg(rmptr);
return;
}
/**
*
* Some list utility functions.
* AddList adds a string to an Exec list. If the list doesn't exist
* yet, it is first created. If sortflag is true, the list is sorted
* using insertion sort.
* NukeList deletes an entire list created by AddList.
*
**/
#define LSIZE ((long) sizeof(struct List))
#define NSIZE ((long) sizeof(struct Node))
static struct List *AddList(list, s, sortflag)
struct List *list;
char *s;
long sortflag;
{
struct Node *n, *nt;
char *ptr;
if (list == NULL) {
list = AllocMem(LSIZE, MEMF_CLEAR);
if (list == NULL) return(NULL);
NewList(list);
}
if (s) {
n = AllocMem(NSIZE, MEMF_CLEAR);
if (n == NULL) return(NukeList(list));
ptr = AllocMem(strlen(s) + 1, 0L);
if (ptr == NULL) return(NukeList(list));
strcpy(ptr, s);
n->ln_Name = ptr;
if (sortflag) {
nt = list->lh_Head;
while (nt->ln_Succ) {
if (stricmp(nt->ln_Name, ptr) >= 0) break;
nt = nt->ln_Succ;
}
Insert(list, n, nt->ln_Pred);
}
else {
AddTail(list, n);
}
}
return(list);
}
static struct List *NukeList(list)
struct List *list;
{
struct Node *n, *nn;
char *ptr;
if (list) {
if (list != (struct List *) list->lh_TailPred) {
n = list->lh_Head;
while (nn = n->ln_Succ) {
Remove(n);
if (ptr = n->ln_Name) FreeMem(ptr, strlen(ptr) + 1);
FreeMem(n, NSIZE);
n = nn;
}
}
FreeMem(list, LSIZE);
}
return(NULL);
}